home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 November / PCWNOV08.iso / Software / Freeware / Adobe Media Player 1.1 / adobe_media_player.air / AMP.swf / scripts / mx / controls / Menu.as < prev    next >
Encoding:
Text File  |  2008-07-17  |  44.9 KB  |  1,269 lines
  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.DisplayObjectContainer;
  5.    import flash.events.Event;
  6.    import flash.events.FocusEvent;
  7.    import flash.events.KeyboardEvent;
  8.    import flash.events.MouseEvent;
  9.    import flash.geom.Point;
  10.    import flash.geom.Rectangle;
  11.    import flash.ui.Keyboard;
  12.    import flash.utils.clearInterval;
  13.    import flash.utils.setTimeout;
  14.    import flash.xml.XMLNode;
  15.    import mx.collections.ArrayCollection;
  16.    import mx.collections.CursorBookmark;
  17.    import mx.collections.ICollectionView;
  18.    import mx.collections.XMLListCollection;
  19.    import mx.controls.listClasses.BaseListData;
  20.    import mx.controls.listClasses.IListItemRenderer;
  21.    import mx.controls.menuClasses.IMenuBarItemRenderer;
  22.    import mx.controls.menuClasses.IMenuDataDescriptor;
  23.    import mx.controls.menuClasses.IMenuItemRenderer;
  24.    import mx.controls.menuClasses.MenuItemRenderer;
  25.    import mx.controls.menuClasses.MenuListData;
  26.    import mx.controls.treeClasses.DefaultDataDescriptor;
  27.    import mx.core.Application;
  28.    import mx.core.ClassFactory;
  29.    import mx.core.EdgeMetrics;
  30.    import mx.core.EventPriority;
  31.    import mx.core.ScrollPolicy;
  32.    import mx.core.UIComponent;
  33.    import mx.core.UIComponentGlobals;
  34.    import mx.core.mx_internal;
  35.    import mx.effects.Tween;
  36.    import mx.events.CollectionEvent;
  37.    import mx.events.CollectionEventKind;
  38.    import mx.events.FlexEvent;
  39.    import mx.events.ListEvent;
  40.    import mx.events.MenuEvent;
  41.    import mx.managers.IFocusManagerContainer;
  42.    import mx.managers.PopUpManager;
  43.    
  44.    use namespace mx_internal;
  45.    
  46.    public class Menu extends List implements IFocusManagerContainer
  47.    {
  48.       mx_internal static var createAccessibilityImplementation:Function;
  49.       
  50.       mx_internal static const VERSION:String = "3.0.0.0";
  51.       
  52.       mx_internal var parentDisplayObject:DisplayObject;
  53.       
  54.       mx_internal var popupTween:Tween;
  55.       
  56.       mx_internal var closeTimer:int = 0;
  57.       
  58.       mx_internal var openSubMenuTimer:int = 0;
  59.       
  60.       mx_internal var showRootChanged:Boolean = false;
  61.       
  62.       mx_internal var sourceMenuBarItem:IMenuBarItemRenderer;
  63.       
  64.       mx_internal var _hasRoot:Boolean = false;
  65.       
  66.       mx_internal var dataProviderChanged:Boolean = false;
  67.       
  68.       private var maxMeasuredTypeIconWidth:Number = 0;
  69.       
  70.       mx_internal var sourceMenuBar:MenuBar;
  71.       
  72.       private var maxMeasuredBranchIconWidth:Number = 0;
  73.       
  74.       private var maxMeasuredIconWidth:Number = 0;
  75.       
  76.       private var subMenu:Menu;
  77.       
  78.       mx_internal var _parentMenu:Menu;
  79.       
  80.       private var useTwoColumns:Boolean = false;
  81.       
  82.       private var hiddenItem:IListItemRenderer;
  83.       
  84.       mx_internal var _showRoot:Boolean = true;
  85.       
  86.       mx_internal var _dataDescriptor:IMenuDataDescriptor;
  87.       
  88.       mx_internal var supposedToLoseFocus:Boolean = false;
  89.       
  90.       private var anchorRow:IListItemRenderer;
  91.       
  92.       mx_internal var _rootModel:ICollectionView;
  93.       
  94.       public function Menu()
  95.       {
  96.          mx_internal::_dataDescriptor = new DefaultDataDescriptor();
  97.          super();
  98.          itemRenderer = new ClassFactory(MenuItemRenderer);
  99.          setRowHeight(19);
  100.          iconField = "icon";
  101.          visible = false;
  102.       }
  103.       
  104.       private static function menuHideHandler(param1:MenuEvent) : void
  105.       {
  106.          var _loc2_:Menu = Menu(param1.target);
  107.          if(!param1.isDefaultPrevented() && param1.menu == _loc2_)
  108.          {
  109.             PopUpManager.removePopUp(_loc2_);
  110.             _loc2_.removeEventListener(MenuEvent.MENU_HIDE,menuHideHandler);
  111.          }
  112.       }
  113.       
  114.       public static function popUpMenu(param1:Menu, param2:DisplayObjectContainer, param3:Object) : void
  115.       {
  116.          param1.mx_internal::parentDisplayObject = !!param2 ? param2 : DisplayObject(Application.application);
  117.          if(!param3)
  118.          {
  119.             param3 = new XML();
  120.          }
  121.          param1.mx_internal::supposedToLoseFocus = true;
  122.          param1.dataProvider = param3;
  123.       }
  124.       
  125.       public static function createMenu(param1:DisplayObjectContainer, param2:Object, param3:Boolean = true) : Menu
  126.       {
  127.          var _loc4_:Menu = new Menu();
  128.          _loc4_.tabEnabled = false;
  129.          _loc4_.owner = DisplayObjectContainer(Application.application);
  130.          _loc4_.showRoot = param3;
  131.          popUpMenu(_loc4_,param1,param2);
  132.          return _loc4_;
  133.       }
  134.       
  135.       private function moveSelBy(param1:Number, param2:Number) : void
  136.       {
  137.          var _loc6_:Object = null;
  138.          var _loc8_:MenuEvent = null;
  139.          var _loc9_:Object = null;
  140.          var _loc3_:Number = param1;
  141.          if(isNaN(_loc3_))
  142.          {
  143.             _loc3_ = -1;
  144.          }
  145.          var _loc4_:Number = Math.max(0,Math.min(rowCount,collection.length) - 1);
  146.          var _loc5_:Number = _loc3_;
  147.          var _loc7_:int = 0;
  148.          while(true)
  149.          {
  150.             _loc5_ += param2;
  151.             if(_loc7_ > _loc4_)
  152.             {
  153.                break;
  154.             }
  155.             _loc7_++;
  156.             if(_loc5_ > _loc4_)
  157.             {
  158.                _loc5_ = 0;
  159.             }
  160.             else if(_loc5_ < 0)
  161.             {
  162.                _loc5_ = _loc4_;
  163.             }
  164.             _loc6_ = listItems[_loc5_][0];
  165.             if(!(Boolean(_loc6_.data) && (mx_internal::_dataDescriptor.getType(_loc6_.data) == "separator" || !mx_internal::_dataDescriptor.isEnabled(_loc6_.data))))
  166.             {
  167.                if(selectedIndex != -1)
  168.                {
  169.                   _loc9_ = listItems[selectedIndex][0];
  170.                   _loc8_ = new MenuEvent(MenuEvent.ITEM_ROLL_OUT);
  171.                   _loc8_.menu = this;
  172.                   _loc8_.index = this.selectedIndex;
  173.                   _loc8_.menuBar = mx_internal::sourceMenuBar;
  174.                   _loc8_.label = itemToLabel(_loc9_.data);
  175.                   _loc8_.item = _loc9_.data;
  176.                   _loc8_.itemRenderer = IListItemRenderer(_loc9_);
  177.                   mx_internal::getRootMenu().dispatchEvent(_loc8_);
  178.                }
  179.                if(_loc6_.data)
  180.                {
  181.                   selectItem(listItems[_loc5_ - verticalScrollPosition][0],false,false);
  182.                   _loc8_ = new MenuEvent(MenuEvent.ITEM_ROLL_OVER);
  183.                   _loc8_.menu = this;
  184.                   _loc8_.index = this.selectedIndex;
  185.                   _loc8_.menuBar = mx_internal::sourceMenuBar;
  186.                   _loc8_.label = itemToLabel(_loc6_.data);
  187.                   _loc8_.item = _loc6_.data;
  188.                   _loc8_.itemRenderer = IListItemRenderer(_loc6_);
  189.                   mx_internal::getRootMenu().dispatchEvent(_loc8_);
  190.                }
  191.                return;
  192.             }
  193.          }
  194.       }
  195.       
  196.       override public function measureWidthOfItems(param1:int = -1, param2:int = 0) : Number
  197.       {
  198.          var _loc6_:CursorBookmark = null;
  199.          var _loc7_:int = 0;
  200.          var _loc8_:int = 0;
  201.          var _loc9_:Boolean = false;
  202.          var _loc10_:Object = null;
  203.          var _loc11_:MenuListData = null;
  204.          var _loc12_:IListItemRenderer = null;
  205.          var _loc13_:IMenuItemRenderer = null;
  206.          var _loc3_:Number = 0;
  207.          var _loc4_:Number = getStyle("leftIconGap");
  208.          var _loc5_:Number = getStyle("rightIconGap");
  209.          maxMeasuredIconWidth = 0;
  210.          maxMeasuredTypeIconWidth = 0;
  211.          maxMeasuredBranchIconWidth = 0;
  212.          useTwoColumns = false;
  213.          if(Boolean(collection) && Boolean(collection.length))
  214.          {
  215.             _loc6_ = iterator.bookmark;
  216.             _loc7_ = param2;
  217.             _loc8_ = 0;
  218.             while(_loc8_ < 2)
  219.             {
  220.                iterator.seek(CursorBookmark.FIRST,param1);
  221.                param2 = _loc7_;
  222.                _loc9_ = false;
  223.                while(param2)
  224.                {
  225.                   _loc10_ = iterator.current;
  226.                   _loc12_ = hiddenItem = mx_internal::getMeasuringRenderer(_loc10_);
  227.                   _loc12_.explicitWidth = NaN;
  228.                   mx_internal::setupRendererFromData(_loc12_,_loc10_);
  229.                   _loc3_ = Math.max(_loc12_.getExplicitOrMeasuredWidth(),_loc3_);
  230.                   if(_loc12_ is IMenuItemRenderer)
  231.                   {
  232.                      _loc13_ = IMenuItemRenderer(_loc12_);
  233.                      if(_loc13_.measuredIconWidth > maxMeasuredIconWidth)
  234.                      {
  235.                         maxMeasuredIconWidth = _loc13_.measuredIconWidth;
  236.                         _loc9_ = true;
  237.                      }
  238.                      if(_loc13_.measuredTypeIconWidth > maxMeasuredTypeIconWidth)
  239.                      {
  240.                         maxMeasuredTypeIconWidth = _loc13_.measuredTypeIconWidth;
  241.                         _loc9_ = true;
  242.                      }
  243.                      if(_loc13_.measuredBranchIconWidth > maxMeasuredBranchIconWidth)
  244.                      {
  245.                         maxMeasuredBranchIconWidth = _loc13_.measuredBranchIconWidth;
  246.                         _loc9_ = true;
  247.                      }
  248.                      if(_loc13_.measuredIconWidth > 0 && Boolean(_loc13_.measuredTypeIconWidth))
  249.                      {
  250.                         useTwoColumns = true;
  251.                         _loc9_ = true;
  252.                      }
  253.                   }
  254.                   param2--;
  255.                   if(!iterator.moveNext())
  256.                   {
  257.                      break;
  258.                   }
  259.                }
  260.                if(_loc8_ == 0)
  261.                {
  262.                   if(!(_loc9_ && (maxMeasuredIconWidth + maxMeasuredTypeIconWidth > _loc4_ || maxMeasuredBranchIconWidth > _loc5_)))
  263.                   {
  264.                      break;
  265.                   }
  266.                }
  267.                _loc8_++;
  268.             }
  269.             iterator.seek(_loc6_,0);
  270.          }
  271.          if(!_loc3_)
  272.          {
  273.             _loc3_ = 200;
  274.          }
  275.          return _loc3_ + (getStyle("paddingLeft") + getStyle("paddingRight"));
  276.       }
  277.       
  278.       override protected function mouseUpHandler(param1:MouseEvent) : void
  279.       {
  280.          var _loc2_:MenuEvent = null;
  281.          var _loc4_:Object = null;
  282.          var _loc5_:Boolean = false;
  283.          if(!enabled || !selectable || !visible)
  284.          {
  285.             return;
  286.          }
  287.          super.mouseUpHandler(param1);
  288.          var _loc3_:IListItemRenderer = mouseEventToItemRenderer(param1);
  289.          if(Boolean(_loc3_) && Boolean(_loc3_.data))
  290.          {
  291.             _loc4_ = _loc3_.data;
  292.          }
  293.          if(_loc4_ != null && mx_internal::_dataDescriptor.isEnabled(_loc4_) && !mx_internal::_dataDescriptor.isBranch(_loc4_))
  294.          {
  295.             _loc5_ = mx_internal::_dataDescriptor.getType(_loc4_) != "radio" || !mx_internal::_dataDescriptor.isToggled(_loc4_);
  296.             if(_loc5_)
  297.             {
  298.                setMenuItemToggled(_loc4_,!mx_internal::_dataDescriptor.isToggled(_loc4_));
  299.             }
  300.             _loc2_ = new MenuEvent(MenuEvent.ITEM_CLICK);
  301.             _loc2_.menu = this;
  302.             _loc2_.index = this.selectedIndex;
  303.             _loc2_.menuBar = mx_internal::sourceMenuBar;
  304.             _loc2_.label = itemToLabel(_loc4_);
  305.             _loc2_.item = _loc4_;
  306.             _loc2_.itemRenderer = _loc3_;
  307.             mx_internal::getRootMenu().dispatchEvent(_loc2_);
  308.             if(_loc5_)
  309.             {
  310.                _loc2_ = new MenuEvent(MenuEvent.CHANGE);
  311.                _loc2_.menu = this;
  312.                _loc2_.index = this.selectedIndex;
  313.                _loc2_.menuBar = mx_internal::sourceMenuBar;
  314.                _loc2_.label = itemToLabel(_loc4_);
  315.                _loc2_.item = _loc4_;
  316.                _loc2_.itemRenderer = _loc3_;
  317.                mx_internal::getRootMenu().dispatchEvent(_loc2_);
  318.             }
  319.             mx_internal::hideAllMenus();
  320.          }
  321.       }
  322.       
  323.       private function isMouseOverMenu(param1:MouseEvent) : Boolean
  324.       {
  325.          var _loc2_:DisplayObject = DisplayObject(param1.target);
  326.          while(_loc2_)
  327.          {
  328.             if(_loc2_ is Menu)
  329.             {
  330.                return true;
  331.             }
  332.             _loc2_ = _loc2_.parent;
  333.          }
  334.          return false;
  335.       }
  336.       
  337.       override protected function focusOutHandler(param1:FocusEvent) : void
  338.       {
  339.          super.focusOutHandler(param1);
  340.          if(!mx_internal::supposedToLoseFocus)
  341.          {
  342.             mx_internal::hideAllMenus();
  343.          }
  344.          mx_internal::supposedToLoseFocus = false;
  345.       }
  346.       
  347.       mx_internal function openSubMenu(param1:IListItemRenderer) : void
  348.       {
  349.          var _loc3_:Menu = null;
  350.          mx_internal::supposedToLoseFocus = true;
  351.          var _loc2_:Menu = mx_internal::getRootMenu();
  352.          if(!IMenuItemRenderer(param1).menu)
  353.          {
  354.             _loc3_ = new Menu();
  355.             _loc3_.parentMenu = this;
  356.             _loc3_.owner = this;
  357.             _loc3_.showRoot = showRoot;
  358.             _loc3_.dataDescriptor = _loc2_.dataDescriptor;
  359.             _loc3_.styleName = _loc2_;
  360.             _loc3_.labelField = _loc2_.labelField;
  361.             _loc3_.labelFunction = _loc2_.labelFunction;
  362.             _loc3_.iconField = _loc2_.iconField;
  363.             _loc3_.iconFunction = _loc2_.iconFunction;
  364.             _loc3_.itemRenderer = _loc2_.itemRenderer;
  365.             _loc3_.rowHeight = _loc2_.rowHeight;
  366.             _loc3_.scaleY = _loc2_.scaleY;
  367.             _loc3_.scaleX = _loc2_.scaleX;
  368.             if(param1.data && mx_internal::_dataDescriptor.isBranch(param1.data) && mx_internal::_dataDescriptor.hasChildren(param1.data))
  369.             {
  370.                _loc3_.dataProvider = mx_internal::_dataDescriptor.getChildren(param1.data);
  371.             }
  372.             _loc3_.mx_internal::sourceMenuBar = mx_internal::sourceMenuBar;
  373.             _loc3_.mx_internal::sourceMenuBarItem = mx_internal::sourceMenuBarItem;
  374.             IMenuItemRenderer(param1).menu = _loc3_;
  375.             PopUpManager.addPopUp(_loc3_,_loc2_,false);
  376.          }
  377.          else
  378.          {
  379.             _loc3_ = IMenuItemRenderer(param1).menu;
  380.          }
  381.          var _loc4_:DisplayObject = DisplayObject(param1);
  382.          var _loc5_:Point = new Point(0,0);
  383.          _loc5_ = _loc4_.localToGlobal(_loc5_);
  384.          if(_loc4_.root)
  385.          {
  386.             _loc5_ = _loc4_.root.globalToLocal(_loc5_);
  387.          }
  388.          _loc3_.show(_loc5_.x + param1.width,_loc5_.y);
  389.          subMenu = _loc3_;
  390.          clearInterval(mx_internal::openSubMenuTimer);
  391.          mx_internal::openSubMenuTimer = 0;
  392.       }
  393.       
  394.       public function get parentMenu() : Menu
  395.       {
  396.          return mx_internal::_parentMenu;
  397.       }
  398.       
  399.       private function parentRowHeightHandler(param1:Event) : void
  400.       {
  401.          rowHeight = parentMenu.rowHeight;
  402.       }
  403.       
  404.       mx_internal function hideAllMenus() : void
  405.       {
  406.          mx_internal::getRootMenu().hide();
  407.          mx_internal::getRootMenu().mx_internal::deleteDependentSubMenus();
  408.       }
  409.       
  410.       override public function dispatchEvent(param1:Event) : Boolean
  411.       {
  412.          var _loc2_:MenuEvent = null;
  413.          if(!(param1 is MenuEvent) && param1 is ListEvent && (param1.type == ListEvent.ITEM_ROLL_OUT || param1.type == ListEvent.ITEM_ROLL_OVER || param1.type == ListEvent.CHANGE))
  414.          {
  415.             param1.stopImmediatePropagation();
  416.          }
  417.          if(!(param1 is MenuEvent) && param1 is ListEvent && param1.type == ListEvent.ITEM_CLICK)
  418.          {
  419.             _loc2_ = new MenuEvent(param1.type,param1.bubbles,param1.cancelable);
  420.             _loc2_.item = ListEvent(param1).itemRenderer.data;
  421.             _loc2_.label = itemToLabel(ListEvent(param1).itemRenderer);
  422.             return super.dispatchEvent(_loc2_);
  423.          }
  424.          return super.dispatchEvent(param1);
  425.       }
  426.       
  427.       mx_internal function deleteDependentSubMenus() : void
  428.       {
  429.          var _loc3_:Menu = null;
  430.          var _loc1_:int = int(listItems.length);
  431.          var _loc2_:int = 0;
  432.          while(_loc2_ < _loc1_)
  433.          {
  434.             if(listItems[_loc2_][0])
  435.             {
  436.                _loc3_ = IMenuItemRenderer(listItems[_loc2_][0]).menu;
  437.                if(_loc3_)
  438.                {
  439.                   _loc3_.mx_internal::deleteDependentSubMenus();
  440.                   PopUpManager.removePopUp(_loc3_);
  441.                   IMenuItemRenderer(listItems[_loc2_][0]).menu = null;
  442.                }
  443.             }
  444.             _loc2_++;
  445.          }
  446.       }
  447.       
  448.       public function hide() : void
  449.       {
  450.          var _loc1_:MenuEvent = null;
  451.          if(visible)
  452.          {
  453.             if(mx_internal::popupTween)
  454.             {
  455.                mx_internal::popupTween.endTween();
  456.             }
  457.             clearSelected();
  458.             if(anchorRow)
  459.             {
  460.                drawItem(anchorRow,false,false);
  461.                anchorRow = null;
  462.             }
  463.             visible = false;
  464.             systemManager.removeEventListener(MouseEvent.MOUSE_DOWN,mouseDownOutsideHandler);
  465.             _loc1_ = new MenuEvent(MenuEvent.MENU_HIDE);
  466.             _loc1_.menu = this;
  467.             _loc1_.menuBar = mx_internal::sourceMenuBar;
  468.             mx_internal::getRootMenu().dispatchEvent(_loc1_);
  469.          }
  470.       }
  471.       
  472.       override public function set horizontalScrollPolicy(param1:String) : void
  473.       {
  474.       }
  475.       
  476.       public function set parentMenu(param1:Menu) : void
  477.       {
  478.          mx_internal::_parentMenu = param1;
  479.          param1.addEventListener(FlexEvent.HIDE,parentHideHandler,false,0,true);
  480.          param1.addEventListener("rowHeightChanged",parentRowHeightHandler,false,0,true);
  481.          param1.addEventListener("iconFieldChanged",parentIconFieldHandler,false,0,true);
  482.          param1.addEventListener("iconFunctionChanged",parentIconFunctionHandler,false,0,true);
  483.          param1.addEventListener("labelFieldChanged",parentLabelFieldHandler,false,0,true);
  484.          param1.addEventListener("labelFunctionChanged",parentLabelFunctionHandler,false,0,true);
  485.          param1.addEventListener("itemRendererChanged",parentItemRendererHandler,false,0,true);
  486.       }
  487.       
  488.       protected function setMenuItemToggled(param1:Object, param2:Boolean) : void
  489.       {
  490.          var _loc3_:String = null;
  491.          var _loc4_:int = 0;
  492.          var _loc5_:IListItemRenderer = null;
  493.          var _loc6_:Object = null;
  494.          itemsSizeChanged = true;
  495.          invalidateDisplayList();
  496.          if(mx_internal::_dataDescriptor.getType(param1) == "radio")
  497.          {
  498.             _loc3_ = mx_internal::_dataDescriptor.getGroupName(param1);
  499.             _loc4_ = 0;
  500.             while(_loc4_ < listItems.length)
  501.             {
  502.                _loc5_ = listItems[_loc4_][0];
  503.                _loc6_ = _loc5_.data;
  504.                if(mx_internal::_dataDescriptor.getType(_loc6_) == "radio" && mx_internal::_dataDescriptor.getGroupName(_loc6_) == _loc3_)
  505.                {
  506.                   mx_internal::_dataDescriptor.setToggled(_loc6_,_loc6_ == param1);
  507.                }
  508.                _loc4_++;
  509.             }
  510.          }
  511.          if(param2 != mx_internal::_dataDescriptor.isToggled(param1))
  512.          {
  513.             mx_internal::_dataDescriptor.setToggled(param1,param2);
  514.          }
  515.       }
  516.       
  517.       override protected function measure() : void
  518.       {
  519.          var _loc1_:EdgeMetrics = null;
  520.          var _loc2_:int = 0;
  521.          super.measure();
  522.          if(!dataProvider || dataProvider.length == 0)
  523.          {
  524.             measuredWidth = 0;
  525.             measuredHeight = 0;
  526.          }
  527.          else
  528.          {
  529.             _loc1_ = viewMetrics;
  530.             measuredMinWidth = measuredWidth = measureWidthOfItems(0,dataProvider.length);
  531.             if(variableRowHeight)
  532.             {
  533.                _loc2_ = measureHeightOfItems(0,dataProvider.length);
  534.             }
  535.             else
  536.             {
  537.                _loc2_ = dataProvider.length * rowHeight;
  538.             }
  539.             measuredMinHeight = measuredHeight = _loc2_ + _loc1_.top + _loc1_.bottom;
  540.          }
  541.       }
  542.       
  543.       override protected function mouseDownHandler(param1:MouseEvent) : void
  544.       {
  545.          var _loc3_:Object = null;
  546.          var _loc2_:IListItemRenderer = mouseEventToItemRenderer(param1);
  547.          if(Boolean(_loc2_) && Boolean(_loc2_.data))
  548.          {
  549.             _loc3_ = _loc2_.data;
  550.          }
  551.          if(_loc3_ && mx_internal::_dataDescriptor.isEnabled(_loc3_) && !mx_internal::_dataDescriptor.isBranch(_loc3_))
  552.          {
  553.             super.mouseDownHandler(param1);
  554.          }
  555.       }
  556.       
  557.       override protected function mouseEventToItemRenderer(param1:MouseEvent) : IListItemRenderer
  558.       {
  559.          var _loc2_:IListItemRenderer = super.mouseEventToItemRenderer(param1);
  560.          if(_loc2_ && _loc2_.data && mx_internal::_dataDescriptor.getType(_loc2_.data) == "separator")
  561.          {
  562.             return null;
  563.          }
  564.          return _loc2_;
  565.       }
  566.       
  567.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  568.       {
  569.          var _loc5_:MenuEvent = null;
  570.          var _loc2_:IListItemRenderer = selectedIndex == -1 ? null : listItems[selectedIndex - verticalScrollPosition][0];
  571.          var _loc3_:Object = !!_loc2_ ? _loc2_.data : null;
  572.          var _loc4_:Menu = !!_loc2_ ? IMenuItemRenderer(_loc2_).menu : null;
  573.          if(param1.keyCode == Keyboard.UP)
  574.          {
  575.             if(_loc3_ && mx_internal::_dataDescriptor.isBranch(_loc3_) && _loc4_ && _loc4_.visible)
  576.             {
  577.                mx_internal::supposedToLoseFocus = true;
  578.                _loc4_.setFocus();
  579.                _loc4_.moveSelBy(_loc4_.dataProvider.length,-1);
  580.             }
  581.             else
  582.             {
  583.                moveSelBy(selectedIndex,-1);
  584.             }
  585.             param1.stopPropagation();
  586.          }
  587.          else if(param1.keyCode == Keyboard.DOWN)
  588.          {
  589.             if(_loc3_ && mx_internal::_dataDescriptor.isBranch(_loc3_) && _loc4_ && _loc4_.visible)
  590.             {
  591.                mx_internal::supposedToLoseFocus = true;
  592.                _loc4_.setFocus();
  593.                _loc4_.moveSelBy(-1,1);
  594.             }
  595.             else
  596.             {
  597.                moveSelBy(selectedIndex,1);
  598.             }
  599.             param1.stopPropagation();
  600.          }
  601.          else if(param1.keyCode == Keyboard.RIGHT)
  602.          {
  603.             if(Boolean(_loc3_) && mx_internal::_dataDescriptor.isBranch(_loc3_))
  604.             {
  605.                mx_internal::openSubMenu(_loc2_);
  606.                _loc4_ = IMenuItemRenderer(_loc2_).menu;
  607.                mx_internal::supposedToLoseFocus = true;
  608.                _loc4_.setFocus();
  609.                _loc4_.moveSelBy(-1,1);
  610.             }
  611.             else if(mx_internal::sourceMenuBar)
  612.             {
  613.                mx_internal::supposedToLoseFocus = true;
  614.                mx_internal::sourceMenuBar.setFocus();
  615.                mx_internal::sourceMenuBar.dispatchEvent(param1);
  616.             }
  617.             param1.stopPropagation();
  618.          }
  619.          else if(param1.keyCode == Keyboard.LEFT)
  620.          {
  621.             if(mx_internal::_parentMenu)
  622.             {
  623.                mx_internal::supposedToLoseFocus = true;
  624.                hide();
  625.                mx_internal::_parentMenu.setFocus();
  626.             }
  627.             else if(mx_internal::sourceMenuBar)
  628.             {
  629.                mx_internal::supposedToLoseFocus = true;
  630.                mx_internal::sourceMenuBar.setFocus();
  631.                mx_internal::sourceMenuBar.dispatchEvent(param1);
  632.             }
  633.             param1.stopPropagation();
  634.          }
  635.          else if(param1.keyCode == Keyboard.ENTER || param1.keyCode == Keyboard.SPACE)
  636.          {
  637.             if(Boolean(_loc3_) && mx_internal::_dataDescriptor.isBranch(_loc3_))
  638.             {
  639.                mx_internal::openSubMenu(_loc2_);
  640.                _loc4_ = IMenuItemRenderer(_loc2_).menu;
  641.                mx_internal::supposedToLoseFocus = true;
  642.                _loc4_.setFocus();
  643.                _loc4_.moveSelBy(-1,1);
  644.             }
  645.             else if(_loc3_)
  646.             {
  647.                setMenuItemToggled(_loc3_,!mx_internal::_dataDescriptor.isToggled(_loc3_));
  648.                _loc5_ = new MenuEvent(MenuEvent.ITEM_CLICK);
  649.                _loc5_.menu = this;
  650.                _loc5_.index = this.selectedIndex;
  651.                _loc5_.menuBar = mx_internal::sourceMenuBar;
  652.                _loc5_.label = itemToLabel(_loc3_);
  653.                _loc5_.item = _loc3_;
  654.                _loc5_.itemRenderer = _loc2_;
  655.                mx_internal::getRootMenu().dispatchEvent(_loc5_);
  656.                _loc5_ = new MenuEvent(MenuEvent.CHANGE);
  657.                _loc5_.menu = this;
  658.                _loc5_.index = this.selectedIndex;
  659.                _loc5_.menuBar = mx_internal::sourceMenuBar;
  660.                _loc5_.label = itemToLabel(_loc3_);
  661.                _loc5_.item = _loc3_;
  662.                _loc5_.itemRenderer = _loc2_;
  663.                mx_internal::getRootMenu().dispatchEvent(_loc5_);
  664.                mx_internal::hideAllMenus();
  665.             }
  666.             param1.stopPropagation();
  667.          }
  668.          else if(param1.keyCode == Keyboard.TAB)
  669.          {
  670.             _loc5_ = new MenuEvent(MenuEvent.MENU_HIDE);
  671.             _loc5_.menu = mx_internal::getRootMenu();
  672.             _loc5_.menuBar = mx_internal::sourceMenuBar;
  673.             mx_internal::getRootMenu().dispatchEvent(_loc5_);
  674.             mx_internal::hideAllMenus();
  675.             param1.stopPropagation();
  676.          }
  677.          else if(param1.keyCode == Keyboard.ESCAPE)
  678.          {
  679.             if(mx_internal::_parentMenu)
  680.             {
  681.                mx_internal::supposedToLoseFocus = true;
  682.                hide();
  683.                mx_internal::_parentMenu.setFocus();
  684.             }
  685.             else
  686.             {
  687.                _loc5_ = new MenuEvent(MenuEvent.MENU_HIDE);
  688.                _loc5_.menu = mx_internal::getRootMenu();
  689.                _loc5_.menuBar = mx_internal::sourceMenuBar;
  690.                mx_internal::getRootMenu().dispatchEvent(_loc5_);
  691.                mx_internal::hideAllMenus();
  692.                param1.stopPropagation();
  693.             }
  694.          }
  695.       }
  696.       
  697.       private function parentItemRendererHandler(param1:Event) : void
  698.       {
  699.          itemRenderer = parentMenu.itemRenderer;
  700.       }
  701.       
  702.       mx_internal function onTweenEnd(param1:Object) : void
  703.       {
  704.          UIComponent.resumeBackgroundProcessing();
  705.          scrollRect = null;
  706.          mx_internal::popupTween = null;
  707.       }
  708.       
  709.       public function set dataDescriptor(param1:IMenuDataDescriptor) : void
  710.       {
  711.          mx_internal::_dataDescriptor = param1;
  712.       }
  713.       
  714.       override public function set dataProvider(param1:Object) : void
  715.       {
  716.          var _loc2_:XMLList = null;
  717.          var _loc3_:Array = null;
  718.          if(mx_internal::_rootModel)
  719.          {
  720.             mx_internal::_rootModel.removeEventListener(CollectionEvent.COLLECTION_CHANGE,collectionChangeHandler);
  721.          }
  722.          if(typeof param1 == "string")
  723.          {
  724.             param1 = new XML(param1);
  725.          }
  726.          else if(param1 is XMLNode)
  727.          {
  728.             param1 = new XML(XMLNode(param1).toString());
  729.          }
  730.          else if(param1 is XMLList)
  731.          {
  732.             param1 = new XMLListCollection(param1 as XMLList);
  733.          }
  734.          if(param1 is XML)
  735.          {
  736.             mx_internal::_hasRoot = true;
  737.             _loc2_ = new XMLList();
  738.             _loc2_ += param1;
  739.             mx_internal::_rootModel = new XMLListCollection(_loc2_);
  740.          }
  741.          else if(param1 is ICollectionView)
  742.          {
  743.             mx_internal::_rootModel = ICollectionView(param1);
  744.             if(mx_internal::_rootModel.length == 1)
  745.             {
  746.                mx_internal::_hasRoot = true;
  747.             }
  748.          }
  749.          else if(param1 is Array)
  750.          {
  751.             mx_internal::_rootModel = new ArrayCollection(param1 as Array);
  752.          }
  753.          else if(param1 is Object)
  754.          {
  755.             mx_internal::_hasRoot = true;
  756.             _loc3_ = [];
  757.             _loc3_.push(param1);
  758.             mx_internal::_rootModel = new ArrayCollection(_loc3_);
  759.          }
  760.          else
  761.          {
  762.             mx_internal::_rootModel = new ArrayCollection();
  763.          }
  764.          mx_internal::_rootModel.addEventListener(CollectionEvent.COLLECTION_CHANGE,collectionChangeHandler,false,0,true);
  765.          mx_internal::dataProviderChanged = true;
  766.          invalidateProperties();
  767.       }
  768.       
  769.       override protected function drawItem(param1:IListItemRenderer, param2:Boolean = false, param3:Boolean = false, param4:Boolean = false, param5:Boolean = false) : void
  770.       {
  771.          if(!getStyle("useRollOver"))
  772.          {
  773.             super.drawItem(param1,param2,false,false,param5);
  774.          }
  775.          else
  776.          {
  777.             super.drawItem(param1,param2,param3,param4,param5);
  778.          }
  779.       }
  780.       
  781.       private function parentLabelFieldHandler(param1:Event) : void
  782.       {
  783.          labelField = parentMenu.labelField;
  784.       }
  785.       
  786.       override protected function collectionChangeHandler(param1:Event) : void
  787.       {
  788.          var _loc2_:CollectionEvent = null;
  789.          if(param1 is CollectionEvent)
  790.          {
  791.             _loc2_ = CollectionEvent(param1);
  792.             if(_loc2_.kind == CollectionEventKind.ADD)
  793.             {
  794.                super.collectionChangeHandler(param1);
  795.                mx_internal::dataProviderChanged = true;
  796.                invalidateSize();
  797.                UIComponentGlobals.mx_internal::layoutManager.validateClient(this);
  798.                setActualSize(getExplicitOrMeasuredWidth(),getExplicitOrMeasuredHeight());
  799.             }
  800.             else if(_loc2_.kind == CollectionEventKind.REMOVE)
  801.             {
  802.                super.collectionChangeHandler(param1);
  803.                mx_internal::dataProviderChanged = true;
  804.                invalidateSize();
  805.                UIComponentGlobals.mx_internal::layoutManager.validateClient(this);
  806.                setActualSize(getExplicitOrMeasuredWidth(),getExplicitOrMeasuredHeight());
  807.             }
  808.             else if(_loc2_.kind == CollectionEventKind.REFRESH)
  809.             {
  810.                invalidateSize();
  811.                invalidateProperties();
  812.             }
  813.             else if(_loc2_.kind == CollectionEventKind.RESET)
  814.             {
  815.                invalidateSize();
  816.                invalidateProperties();
  817.             }
  818.          }
  819.          itemsSizeChanged = true;
  820.          invalidateDisplayList();
  821.       }
  822.       
  823.       override protected function makeListData(param1:Object, param2:String, param3:int) : BaseListData
  824.       {
  825.          var _loc4_:MenuListData = new MenuListData(itemToLabel(param1),itemToIcon(param1),labelField,param2,this,param3);
  826.          _loc4_.maxMeasuredIconWidth = maxMeasuredIconWidth;
  827.          _loc4_.maxMeasuredTypeIconWidth = maxMeasuredTypeIconWidth;
  828.          _loc4_.maxMeasuredBranchIconWidth = maxMeasuredBranchIconWidth;
  829.          _loc4_.useTwoColumns = useTwoColumns;
  830.          return _loc4_;
  831.       }
  832.       
  833.       public function get showRoot() : Boolean
  834.       {
  835.          return mx_internal::_showRoot;
  836.       }
  837.       
  838.       private function parentLabelFunctionHandler(param1:Event) : void
  839.       {
  840.          labelFunction = parentMenu.labelFunction;
  841.       }
  842.       
  843.       private function getRowIndex(param1:IListItemRenderer) : int
  844.       {
  845.          var _loc3_:IListItemRenderer = null;
  846.          var _loc2_:int = 0;
  847.          while(_loc2_ < listItems.length)
  848.          {
  849.             _loc3_ = listItems[_loc2_][0];
  850.             if(_loc3_ && _loc3_.data && mx_internal::_dataDescriptor.getType(_loc3_.data) != "separator")
  851.             {
  852.                if(_loc3_ == param1)
  853.                {
  854.                   return _loc2_;
  855.                }
  856.             }
  857.             _loc2_++;
  858.          }
  859.          return -1;
  860.       }
  861.       
  862.       private function parentIconFunctionHandler(param1:Event) : void
  863.       {
  864.          iconFunction = parentMenu.iconFunction;
  865.       }
  866.       
  867.       mx_internal function get subMenus() : Array
  868.       {
  869.          var _loc1_:Array = [];
  870.          var _loc2_:int = 0;
  871.          while(_loc2_ < listItems.length)
  872.          {
  873.             _loc1_.push(listItems[_loc2_][0].menu);
  874.             _loc2_++;
  875.          }
  876.          return _loc1_;
  877.       }
  878.       
  879.       override public function setFocus() : void
  880.       {
  881.          super.setFocus();
  882.       }
  883.       
  884.       public function get hasRoot() : Boolean
  885.       {
  886.          return mx_internal::_hasRoot;
  887.       }
  888.       
  889.       private function parentHideHandler(param1:FlexEvent) : void
  890.       {
  891.          visible = false;
  892.       }
  893.       
  894.       override protected function initializeAccessibility() : void
  895.       {
  896.          if(mx_internal::createAccessibilityImplementation != null)
  897.          {
  898.             mx_internal::createAccessibilityImplementation(this);
  899.          }
  900.       }
  901.       
  902.       private function closeSubMenu(param1:Menu) : void
  903.       {
  904.          param1.hide();
  905.          clearInterval(param1.mx_internal::closeTimer);
  906.          param1.mx_internal::closeTimer = 0;
  907.       }
  908.       
  909.       override protected function mouseOutHandler(param1:MouseEvent) : void
  910.       {
  911.          var _loc3_:Object = null;
  912.          if(!enabled || !selectable || !visible)
  913.          {
  914.             return;
  915.          }
  916.          systemManager.removeEventListener(MouseEvent.MOUSE_UP,mouseUpHandler,true);
  917.          var _loc2_:IListItemRenderer = mouseEventToItemRenderer(param1);
  918.          if(!_loc2_)
  919.          {
  920.             return;
  921.          }
  922.          if(Boolean(_loc2_) && Boolean(_loc2_.data))
  923.          {
  924.             _loc3_ = _loc2_.data;
  925.          }
  926.          if(mx_internal::openSubMenuTimer)
  927.          {
  928.             clearInterval(mx_internal::openSubMenuTimer);
  929.             mx_internal::openSubMenuTimer = 0;
  930.          }
  931.          if(itemRendererContains(_loc2_,param1.relatedObject) || itemRendererContains(_loc2_,DisplayObject(param1.target)) || param1.relatedObject == highlightIndicator || param1.relatedObject == listContent || !highlightItemRenderer)
  932.          {
  933.             return;
  934.          }
  935.          if(getStyle("useRollOver") && Boolean(_loc3_))
  936.          {
  937.             mx_internal::clearHighlight(_loc2_);
  938.          }
  939.       }
  940.       
  941.       override public function get horizontalScrollPolicy() : String
  942.       {
  943.          return ScrollPolicy.OFF;
  944.       }
  945.       
  946.       private function mouseDownOutsideHandler(param1:MouseEvent) : void
  947.       {
  948.          if(!isMouseOverMenu(param1) && !isMouseOverMenuBarItem(param1))
  949.          {
  950.             mx_internal::hideAllMenus();
  951.          }
  952.       }
  953.       
  954.       override protected function configureScrollBars() : void
  955.       {
  956.       }
  957.       
  958.       public function get dataDescriptor() : IMenuDataDescriptor
  959.       {
  960.          return IMenuDataDescriptor(mx_internal::_dataDescriptor);
  961.       }
  962.       
  963.       override public function get dataProvider() : Object
  964.       {
  965.          var _loc1_:* = super.dataProvider;
  966.          if(_loc1_ == null)
  967.          {
  968.             if(mx_internal::_rootModel != null)
  969.             {
  970.                return mx_internal::_rootModel;
  971.             }
  972.             return null;
  973.          }
  974.          return _loc1_;
  975.       }
  976.       
  977.       override public function styleChanged(param1:String) : void
  978.       {
  979.          super.styleChanged(param1);
  980.          mx_internal::deleteDependentSubMenus();
  981.       }
  982.       
  983.       mx_internal function onTweenUpdate(param1:Object) : void
  984.       {
  985.          scrollRect = new Rectangle(0,0,param1[0],param1[1]);
  986.       }
  987.       
  988.       override protected function commitProperties() : void
  989.       {
  990.          var _loc1_:ICollectionView = null;
  991.          var _loc2_:* = undefined;
  992.          if(mx_internal::showRootChanged)
  993.          {
  994.             if(!mx_internal::_hasRoot)
  995.             {
  996.                mx_internal::showRootChanged = false;
  997.             }
  998.          }
  999.          if(mx_internal::dataProviderChanged || mx_internal::showRootChanged)
  1000.          {
  1001.             mx_internal::dataProviderChanged = false;
  1002.             mx_internal::showRootChanged = false;
  1003.             if(mx_internal::_rootModel && !mx_internal::_showRoot && mx_internal::_hasRoot)
  1004.             {
  1005.                _loc2_ = mx_internal::_rootModel.createCursor().current;
  1006.                if(_loc2_ != null && mx_internal::_dataDescriptor.isBranch(_loc2_,mx_internal::_rootModel) && mx_internal::_dataDescriptor.hasChildren(_loc2_,mx_internal::_rootModel))
  1007.                {
  1008.                   _loc1_ = mx_internal::_dataDescriptor.getChildren(_loc2_,mx_internal::_rootModel);
  1009.                }
  1010.             }
  1011.             if(mx_internal::_rootModel)
  1012.             {
  1013.                if(!_loc1_)
  1014.                {
  1015.                   _loc1_ = mx_internal::_rootModel;
  1016.                }
  1017.                super.dataProvider = _loc1_;
  1018.                _loc1_.addEventListener(CollectionEvent.COLLECTION_CHANGE,collectionChangeHandler,false,EventPriority.DEFAULT_HANDLER,true);
  1019.             }
  1020.             else
  1021.             {
  1022.                super.dataProvider = null;
  1023.             }
  1024.          }
  1025.          super.commitProperties();
  1026.       }
  1027.       
  1028.       private function parentIconFieldHandler(param1:Event) : void
  1029.       {
  1030.          iconField = parentMenu.iconField;
  1031.       }
  1032.       
  1033.       mx_internal function getRootMenu() : Menu
  1034.       {
  1035.          var _loc1_:Menu = this;
  1036.          while(_loc1_.parentMenu)
  1037.          {
  1038.             _loc1_ = _loc1_.parentMenu;
  1039.          }
  1040.          return _loc1_;
  1041.       }
  1042.       
  1043.       override mx_internal function clearHighlight(param1:IListItemRenderer) : void
  1044.       {
  1045.          var _loc4_:MenuEvent = null;
  1046.          var _loc2_:String = itemToUID(param1.data);
  1047.          drawItem(visibleData[_loc2_],isItemSelected(param1.data),false,_loc2_ == caretUID);
  1048.          var _loc3_:Point = itemRendererToIndices(param1);
  1049.          if(_loc3_)
  1050.          {
  1051.             _loc4_ = new MenuEvent(MenuEvent.ITEM_ROLL_OUT);
  1052.             _loc4_.menu = this;
  1053.             _loc4_.index = getRowIndex(param1);
  1054.             _loc4_.menuBar = mx_internal::sourceMenuBar;
  1055.             _loc4_.label = itemToLabel(param1.data);
  1056.             _loc4_.item = param1.data;
  1057.             _loc4_.itemRenderer = param1;
  1058.             mx_internal::getRootMenu().dispatchEvent(_loc4_);
  1059.          }
  1060.       }
  1061.       
  1062.       override public function set verticalScrollPolicy(param1:String) : void
  1063.       {
  1064.       }
  1065.       
  1066.       override protected function mouseClickHandler(param1:MouseEvent) : void
  1067.       {
  1068.       }
  1069.       
  1070.       private function isMouseOverMenuBarItem(param1:MouseEvent) : Boolean
  1071.       {
  1072.          if(!mx_internal::sourceMenuBarItem)
  1073.          {
  1074.             return false;
  1075.          }
  1076.          var _loc2_:DisplayObject = DisplayObject(param1.target);
  1077.          while(_loc2_)
  1078.          {
  1079.             if(_loc2_ == mx_internal::sourceMenuBarItem)
  1080.             {
  1081.                return true;
  1082.             }
  1083.             _loc2_ = _loc2_.parent;
  1084.          }
  1085.          return false;
  1086.       }
  1087.       
  1088.       override protected function mouseOverHandler(param1:MouseEvent) : void
  1089.       {
  1090.          var row:IListItemRenderer;
  1091.          var item:Object = null;
  1092.          var menuEvent:MenuEvent = null;
  1093.          var event:MouseEvent = param1;
  1094.          if(!enabled || !selectable || !visible)
  1095.          {
  1096.             return;
  1097.          }
  1098.          systemManager.addEventListener(MouseEvent.MOUSE_UP,mouseUpHandler,true,0,true);
  1099.          row = mouseEventToItemRenderer(event);
  1100.          if(!row)
  1101.          {
  1102.             return;
  1103.          }
  1104.          if(Boolean(row) && Boolean(row.data))
  1105.          {
  1106.             item = row.data;
  1107.          }
  1108.          if(Boolean(row) && row != anchorRow)
  1109.          {
  1110.             if(anchorRow)
  1111.             {
  1112.                drawItem(anchorRow,false,false);
  1113.             }
  1114.             if(subMenu)
  1115.             {
  1116.                subMenu.mx_internal::supposedToLoseFocus = true;
  1117.                subMenu.mx_internal::closeTimer = setTimeout(closeSubMenu,250,subMenu);
  1118.             }
  1119.             subMenu = null;
  1120.             anchorRow = null;
  1121.          }
  1122.          else if(Boolean(subMenu) && Boolean(subMenu.subMenu))
  1123.          {
  1124.             subMenu.subMenu.hide();
  1125.          }
  1126.          if(mx_internal::_dataDescriptor.isBranch(item) && mx_internal::_dataDescriptor.isEnabled(item))
  1127.          {
  1128.             anchorRow = row;
  1129.             if(Boolean(subMenu) && Boolean(subMenu.mx_internal::closeTimer))
  1130.             {
  1131.                clearInterval(subMenu.mx_internal::closeTimer);
  1132.                subMenu.mx_internal::closeTimer = 0;
  1133.             }
  1134.             if(!subMenu || !subMenu.visible)
  1135.             {
  1136.                if(mx_internal::openSubMenuTimer)
  1137.                {
  1138.                   clearInterval(mx_internal::openSubMenuTimer);
  1139.                }
  1140.                mx_internal::openSubMenuTimer = setTimeout(function(param1:IListItemRenderer):void
  1141.                {
  1142.                   mx_internal::openSubMenu(param1);
  1143.                },250,row);
  1144.             }
  1145.          }
  1146.          if(Boolean(item) && mx_internal::_dataDescriptor.isEnabled(item))
  1147.          {
  1148.             if(event.relatedObject)
  1149.             {
  1150.                if(itemRendererContains(row,event.relatedObject) || row == mx_internal::lastHighlightItemRenderer || event.relatedObject == highlightIndicator)
  1151.                {
  1152.                   return;
  1153.                }
  1154.             }
  1155.          }
  1156.          if(row)
  1157.          {
  1158.             drawItem(row,false,Boolean(item && mx_internal::_dataDescriptor.isEnabled(item)));
  1159.             if(Boolean(item) && mx_internal::_dataDescriptor.isEnabled(item))
  1160.             {
  1161.                menuEvent = new MenuEvent(MenuEvent.ITEM_ROLL_OVER);
  1162.                menuEvent.menu = this;
  1163.                menuEvent.index = getRowIndex(row);
  1164.                menuEvent.menuBar = mx_internal::sourceMenuBar;
  1165.                menuEvent.label = itemToLabel(item);
  1166.                menuEvent.item = item;
  1167.                menuEvent.itemRenderer = row;
  1168.                mx_internal::getRootMenu().dispatchEvent(menuEvent);
  1169.             }
  1170.          }
  1171.       }
  1172.       
  1173.       override public function get verticalScrollPolicy() : String
  1174.       {
  1175.          return ScrollPolicy.OFF;
  1176.       }
  1177.       
  1178.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  1179.       {
  1180.          super.updateDisplayList(param1,param2);
  1181.          border.move(0,0);
  1182.          border.visible = dataProvider != null && dataProvider.length > 0;
  1183.          if(hiddenItem)
  1184.          {
  1185.             hiddenItem.setActualSize(param1,hiddenItem.getExplicitOrMeasuredHeight());
  1186.          }
  1187.       }
  1188.       
  1189.       public function show(param1:Object = null, param2:Object = null) : void
  1190.       {
  1191.          var _loc5_:Number = NaN;
  1192.          if(Boolean(collection) && collection.length == 0)
  1193.          {
  1194.             return;
  1195.          }
  1196.          if(Boolean(parentMenu) && !parentMenu.visible)
  1197.          {
  1198.             return;
  1199.          }
  1200.          if(visible)
  1201.          {
  1202.             return;
  1203.          }
  1204.          if(Boolean(mx_internal::parentDisplayObject) && parent != mx_internal::parentDisplayObject)
  1205.          {
  1206.             PopUpManager.addPopUp(this,mx_internal::parentDisplayObject,false);
  1207.             addEventListener(MenuEvent.MENU_HIDE,menuHideHandler,false,EventPriority.DEFAULT_HANDLER);
  1208.          }
  1209.          var _loc3_:MenuEvent = new MenuEvent(MenuEvent.MENU_SHOW);
  1210.          _loc3_.menu = this;
  1211.          _loc3_.menuBar = mx_internal::sourceMenuBar;
  1212.          mx_internal::getRootMenu().dispatchEvent(_loc3_);
  1213.          systemManager.activate(this);
  1214.          if(param1 !== null && !isNaN(Number(param1)))
  1215.          {
  1216.             x = Number(param1);
  1217.          }
  1218.          if(param2 !== null && !isNaN(Number(param2)))
  1219.          {
  1220.             y = Number(param2);
  1221.          }
  1222.          if(this != mx_internal::getRootMenu())
  1223.          {
  1224.             _loc5_ = x + width - screen.width;
  1225.             if(_loc5_ > 0)
  1226.             {
  1227.                x = Math.max(x - _loc5_,0);
  1228.             }
  1229.             _loc5_ = y + height - screen.height;
  1230.             if(_loc5_ > 0)
  1231.             {
  1232.                y = Math.max(y - _loc5_,0);
  1233.             }
  1234.          }
  1235.          UIComponentGlobals.mx_internal::layoutManager.validateClient(this,true);
  1236.          setActualSize(getExplicitOrMeasuredWidth(),getExplicitOrMeasuredHeight());
  1237.          cacheAsBitmap = true;
  1238.          var _loc4_:Number = getStyle("openDuration");
  1239.          if(_loc4_ != 0)
  1240.          {
  1241.             scrollRect = new Rectangle(0,0,unscaledWidth,0);
  1242.             visible = true;
  1243.             UIComponentGlobals.mx_internal::layoutManager.validateNow();
  1244.             UIComponent.suspendBackgroundProcessing();
  1245.             mx_internal::popupTween = new Tween(this,[0,0],[unscaledWidth,unscaledHeight],_loc4_);
  1246.          }
  1247.          else
  1248.          {
  1249.             UIComponentGlobals.mx_internal::layoutManager.validateNow();
  1250.             visible = true;
  1251.          }
  1252.          focusManager.setFocus(this);
  1253.          mx_internal::supposedToLoseFocus = true;
  1254.          systemManager.addEventListener(MouseEvent.MOUSE_DOWN,mouseDownOutsideHandler,false,0,true);
  1255.       }
  1256.       
  1257.       public function set showRoot(param1:Boolean) : void
  1258.       {
  1259.          if(mx_internal::_showRoot != param1)
  1260.          {
  1261.             mx_internal::_showRoot = param1;
  1262.             mx_internal::showRootChanged = true;
  1263.             invalidateProperties();
  1264.          }
  1265.       }
  1266.    }
  1267. }
  1268.  
  1269.